// Dart并发编程综合示例
// 展示在实际应用中如何结合使用Isolate、Future和Stream

import 'dart:async';
import 'dart:isolate';
import 'dart:math';

// 模拟一个耗时的计算任务
int performExpensiveCalculation(int value) {
  // 模拟复杂计算
  var result = 0;
  for (var i = 0; i < value * 100000; i++) {
    result += i;
  }
  return result;
}

// 在隔离区中运行的函数
void isolateWorker(List<dynamic> args) {
  final SendPort sendPort = args[0];
  final int value = args[1];

  // 执行耗时计算
  final result = performExpensiveCalculation(value);

  // 将结果发送回主隔离区
  sendPort.send(result);
}

// 使用隔离区执行并行计算
Future<int> calculateInIsolate(int value) async {
  // 创建一个接收端口
  final receivePort = ReceivePort();

  // 启动隔离区
  final isolate = await Isolate.spawn(isolateWorker, [
    receivePort.sendPort,
    value,
  ]);

  // 获取结果
  final result = await receivePort.first;

  // 关闭隔离区和端口
  isolate.kill();
  receivePort.close();

  return result;
}

// 模拟数据处理管道
class DataProcessor {
  final _controller = StreamController<int>();
  final _resultController = StreamController<int>();
  final _progressController = StreamController<double>();

  Stream<int> get resultStream => _resultController.stream;
  Stream<double> get progressStream => _progressController.stream;

  int _totalTasks = 0;
  int _completedTasks = 0;

  DataProcessor() {
    // 设置数据处理管道
    _controller.stream
        .asyncMap((value) => calculateInIsolate(value))
        .listen(
          (result) {
            _resultController.add(result);
            _updateProgress();
          },
          onError: (error) => _resultController.addError(error),
          onDone: () {
            _resultController.close();
            _progressController.close();
          },
        );
  }

  // 添加数据到处理管道
  void addData(int value) {
    _totalTasks++;
    _controller.add(value);
  }

  // 批量添加数据
  void addBatchData(List<int> values) {
    _totalTasks += values.length;
    values.forEach(_controller.add);
  }

  // 更新进度
  void _updateProgress() {
    _completedTasks++;
    if (_totalTasks > 0) {
      _progressController.add(_completedTasks / _totalTasks);
    }
  }

  // 关闭处理器
  void close() {
    _controller.close();
    _progressController.close();
  }
}

// 模拟数据源
class DataSource {
  final _random = Random();
  final _controller = StreamController<int>.broadcast();

  Stream<int> get dataStream => _controller.stream;

  // 开始生成数据
  void start() {
    // 每500毫秒生成一个随机数
    Timer.periodic(Duration(milliseconds: 500), (timer) {
      if (_controller.isClosed) {
        timer.cancel();
        return;
      }

      final value = _random.nextInt(10) + 1;
      print('数据源生成: $value');
      _controller.add(value);
    });
  }

  // 停止生成数据
  void stop() {
    _controller.close();
  }
}

// 主函数：展示并发处理流程
Future<void> main() async {
  print('Dart并发编程综合示例');
  print('-------------------');

  // 创建数据源
  final dataSource = DataSource();

  // 创建数据处理器
  final processor = DataProcessor();

  // 监听处理结果
  processor.resultStream.listen(
    (result) => print('处理结果: $result'),
    onError: (error) => print('处理错误: $error'),
    onDone: () => print('处理完成'),
  );

  // 连接数据源到处理器
  dataSource.dataStream.listen(
    (data) => processor.addData(data),
    onDone: () => processor.close(),
  );

  // 开始生成数据
  print('开始数据处理流程...');
  dataSource.start();

  // 运行5秒后停止
  await Future.delayed(Duration(seconds: 5));
  print('\n停止数据生成...');
  dataSource.stop();

  // 等待所有处理完成
  await Future.delayed(Duration(seconds: 2));
  print('\n示例结束');

  print('\n总结:');
  print('1. 使用Isolate进行CPU密集型计算，避免阻塞主线程');
  print('2. 使用Stream处理异步数据流');
  print('3. 使用Future协调异步操作');
  print('4. 结合这些技术可以构建高效的并发应用');
}
